package cn.usian.jyzx.product.service.impl;

import cn.usian.jyzx.model.entity.product.Category;
import cn.usian.jyzx.product.mapper.CategoryMapper;
import cn.usian.jyzx.product.service.CategoryService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @TODO:
 * @Author:baimu
 * @Date:2024 10 30 11 01
 **/

@Service
@Slf4j
public class CategoryServiceImpl  implements CategoryService {

    @Autowired
    CategoryMapper categoryMapper;


    @Autowired
    RedisTemplate redisTemplate;
    @Override
    public List<Category> findByParentId(Long parentId) {
        return categoryMapper.findByParentId(parentId);
    }

    @Override
    public List<Category> findAllCategory1() {
        //1:先查一级
        List<Category> oneCategoryList = categoryMapper.findByParentId(0L);
        //2:遍历一级，得到的每个一级下面的二级
//        for(Category category:oneCategoryList){
//            //一级ID
//            Long id = category.getId();
//            //二级
//            List<Category> twoCategoryList = categoryMapper.findByParentId(id);
//            category.setChildren(twoCategoryList);
//            //3:遍历二级，得到的每个二级下面的三级
//            for(Category category2:twoCategoryList){
//                Long id1 = category2.getId();
//                List<Category> threeCategoryList = categoryMapper.findByParentId(id1);
//                category2.setChildren(threeCategoryList);
//            }
//
//        }
        oneCategoryList.forEach(
                category -> {
                    Long id = category.getId();
                    List<Category> twoCategoryList = categoryMapper.findByParentId(id);
                    category.setChildren(twoCategoryList);
                    twoCategoryList.forEach(category1 -> {
                        Long id1 = category1.getId();
                        List<Category> threeCategoryList = categoryMapper.findByParentId(id1);
                        category1.setChildren(threeCategoryList);
                    });
                }
        );


        return oneCategoryList;
    }


    public List<Category> findAllCategory3(){
        List<Category> allCategoryList = categoryMapper.findAll();
        //从所有的分类数据查询一级分类
        //stream 流
        /**
         * 以下是对这段 Java 代码的解释：
         * 这段代码使用 Java 8 的 Stream API 对一个包含Category对象的列表allCategoryList进行操作，目的是筛选出父 ID 为 0 的Category对象，并将结果收集到一个新的列表中。
         * allCategoryList.stream()：将原始列表转换为一个流（Stream），这样可以使用流的各种操作来处理元素。
         * .filter(category -> category.getParentId() == 0)：使用filter方法对流中的元素进行筛选，只保留满足条件的元素。这里的条件是category.getParentId() == 0，即筛选出父 ID 为 0 的Category对象。
         * .collect(Collectors.toList())：使用collect方法将流中的元素收集到一个新的列表中。Collectors.toList()是一个收集器，它将流中的元素收集到一个List中。
         * 最终，代码将得到一个只包含父 ID 为 0 的Category对象的新列表oneCategoryList。
         * 这种使用 Stream API 的方式具有以下优点：
         * 代码简洁：相比传统的循环遍历方式，Stream API 提供了一种更简洁、更具表达力的方式来处理集合。
         * 函数式编程风格：可以使用函数式编程的方式来处理数据，提高代码的可读性和可维护性。
         * 并行处理：Stream API 可以很容易地进行并行处理，提高处理大型数据集的性能。
         */
        List<Category> oneCategoryList = allCategoryList
                .stream()
                .filter(category -> category.getParentId() == 0)
                .collect(Collectors.toList());

        oneCategoryList.forEach(category1 ->{
            List<Category> twoCategoryList = allCategoryList
                    .stream()
                    .filter(category2 -> category2.getParentId().intValue() == category1.getId().intValue())
                    .collect(Collectors.toList());
            category1.setChildren(twoCategoryList);

            twoCategoryList.forEach(
                    category2->{
                        List<Category> threeCategoryList = allCategoryList
                                .stream()
                                .filter(category3 -> category3.getParentId().intValue() == category2.getId())
                                .collect(Collectors.toList());
                        category2.setChildren(threeCategoryList);

                    }
            );

        });

    return oneCategoryList;

    }
    /**
     * redis 缓存
     * set  key -value
     * key：allCategoryList       value：List
     * get  key
     *
     * set
     * get
     *
     *
     * 1：从redis查询，有--》return
     * 2：没有--》mysql---》set redis
     *
     * @return
     */

    @Override
    public List<Category> findAllCategory2() {


        List<Category> allCategoryList = redisTemplate.opsForList().range("allCategoryList", 0, -1);
        if(null!=allCategoryList&&allCategoryList.size()>0){
            log.info("redis 有值：{}",allCategoryList);
            return allCategoryList;
        }else{
            log.info("redis 没有值：{}",allCategoryList);
            // 查询所有分类
            List<Category> allCategories = categoryMapper.findAll();
            // 构建层级关系
            List<Category> rootCategories = new ArrayList<>();
//        for (Category category : allCategories) {
//            if (category.getParentId() == 0L) {
//                buildChildren(category, allCategories);
//                rootCategories.add(category);
//            }
//        }

            allCategories.forEach(
                    category ->{
                        if (category.getParentId() == 0L) {
                            buildChildren(category, allCategories);
                            rootCategories.add(category);
                        }
                    }
            );

            redisTemplate.opsForList().rightPushAll("allCategoryList", rootCategories);

            return rootCategories;
        }









    }

    /**
     * 递归构建子节点
     * @param parentCategory
     * @param allCategories
     */
    private void buildChildren(Category parentCategory, List<Category> allCategories) {
        List<Category> children = new ArrayList<>();



//        for (Category category : allCategories) {
//
//
//            if (category.getParentId().intValue()==parentCategory.getId().intValue()) {
//                log.info("找到子分类了-------------------------------------------------------");
//                buildChildren(category, allCategories);
//                children.add(category);
//            }
//        }


        allCategories.forEach(category ->{
            if (category.getParentId().intValue()==parentCategory.getId().intValue()) {
                log.info("找到子分类了-------------------------------------------------------");
                buildChildren(category, allCategories);
                children.add(category);
            }
        });


        parentCategory.setChildren(children);
    }
}
